﻿template <typename T, typename Container = std::vector<T>, typename Compare = less<T> >
class priority_queue
{
public:
    void Adjustup(Container& c)
    {
        int child = c.size() - 1;
        int parent = (child - 1) / 2;
        //Container::iterator it = c.begin();  //使用错误
        //这里不能使用Container::iterator it;这里使用模板类的成员，必须指定具体类型才可使用，编译器识别不了具体指类型还是静态变量
// 编译器这里是分开编译的，先编译模板，后编译实例化，然后两个地方合在一起
//当编译到模板这块还不知道Container是什么具体类型，无法使用迭代器，模板都存在这个问题
//这里可以使用template来说明是其类型，进行推演，等到实例化然后再去里面取
// 不用template可用auto直接万能接收类型，等编译到实例化时进行确定
        auto it = c.begin();  //这里不用函数和类，因此不能使用模板，直接auto识别即可
        while (parent >= 0 && *(it + child) > *(it + parent)) {
            std::swap(*(it + child), *(it + parent));
            child = parent;
            parent = (child - 1) / 2;
        }
    }
    void Adjustdown(Container& c) {
        int parent = 0;
        int child = parent * 2 + 1;
        //Container::iterator it = c.begin();  
        auto it = c.begin();
        while (child < c.size()) {
            if (child + 1 < c.size() && *(it + child + 1) > *(it + child)) {
                child++;
            }
            if (*(it + child) > *(it + parent)) {
                std::swap(*(it + child), *(it + parent));
                parent = child;
                child = parent * 2 + 1;
            }
            else {
                break;
            }
        }
    }
    template <class InputIterator>//与上同理，这里直接使用万能推演，编译到这块时，会根据后面进行推演
    priority_queue(InputIterator first, InputIterator last)
        :c(first, last)
    {
        for (int i = (c.size() - 1) / 2; i >= 0; i--) {
            Adjustdown(c);
        }
    }
private:
    Container c;
    Compare comp;
};